export const questions = {
  'js-1': {
    title: 'JavaScript中的闭包是什么？',
    category: 'JavaScript 基础',
    tags: ['闭包', '作用域', '内存'],
    description: `
      <p>闭包是指有权访问另一个函数作用域中的变量的函数。创建闭包的常见方式是在一个函数内部创建另一个函数。</p>
      <p>闭包的主要用途：</p>
      <ul>
        <li>数据私有化</li>
        <li>函数工厂</li>
        <li>模块化开发</li>
      </ul>
    `,
    code: `
function createCounter() {
  let count = 0;
  return {
    increment() {
      count++;
      return count;
    },
    decrement() {
      count--;
      return count;
    },
    getCount() {
      return count;
    }
  };
}

const counter = createCounter();
console.log(counter.increment()); // 1
console.log(counter.increment()); // 2
console.log(counter.decrement()); // 1
console.log(counter.getCount()); // 1
    `,
    analysis: `
      <p>在这个例子中，我们创建了一个计数器函数，它返回一个包含三个方法的对象：</p>
      <ul>
        <li>increment(): 增加计数并返回新值</li>
        <li>decrement(): 减少计数并返回新值</li>
        <li>getCount(): 获取当前计数值</li>
      </ul>
      <p>变量 count 被闭包保护，外部无法直接访问，只能通过返回的方法来操作。这展示了闭包在数据封装方面的应用。</p>
    `
  },
  'js-2': {
    title: 'Promise的基本用法',
    category: 'JavaScript 基础',
    tags: ['Promise', '异步', 'ES6'],
    description: `
      <p>Promise 是 JavaScript 中处理异步操作的一种解决方案，它代表一个异步操作的最终完成（或失败）及其结果值。</p>
      <p>Promise 有三种状态：</p>
      <ul>
        <li>pending: 初始状态，既不是成功，也不是失败</li>
        <li>fulfilled: 操作成功完成</li>
        <li>rejected: 操作失败</li>
      </ul>
    `,
    code: `
// 创建一个 Promise
const promise = new Promise((resolve, reject) => {
  // 模拟异步操作
  setTimeout(() => {
    const random = Math.random();
    if (random > 0.5) {
      resolve('成功！');
    } else {
      reject('失败！');
    }
  }, 1000);
});

// 使用 Promise
promise
  .then(result => {
    console.log('成功:', result);
  })
  .catch(error => {
    console.log('失败:', error);
  })
  .finally(() => {
    console.log('完成！');
  });
    `,
    analysis: `
      <p>这个例子展示了 Promise 的基本用法：</p>
      <ul>
        <li>使用 new Promise() 创建一个新的 Promise 实例</li>
        <li>Promise 构造函数接收一个函数作为参数，该函数有两个参数：resolve 和 reject</li>
        <li>使用 .then() 处理成功的情况</li>
        <li>使用 .catch() 处理失败的情况</li>
        <li>使用 .finally() 处理无论成功失败都需要执行的代码</li>
      </ul>
    `
  },
  'es6-1': {
    title: 'ES6中的解构赋值',
    category: 'ES6+ 特性',
    tags: ['解构赋值', 'ES6', '数组', '对象'],
    description: `
      <p>解构赋值是 ES6 引入的一种新的语法，允许我们按照一定模式从数组或对象中提取值，对变量进行赋值。</p>
      <p>解构赋值可以用于：</p>
      <ul>
        <li>数组解构</li>
        <li>对象解构</li>
        <li>嵌套解构</li>
        <li>默认值</li>
      </ul>
    `,
    code: `
// 数组解构
const [a, b, ...rest] = [1, 2, 3, 4, 5];
console.log(a);    // 1
console.log(b);    // 2
console.log(rest); // [3, 4, 5]

// 对象解构
const person = {
  name: 'John',
  age: 30,
  address: {
    city: 'New York',
    country: 'USA'
  }
};

const { name, age, address: { city } } = person;
console.log(name); // 'John'
console.log(age);  // 30
console.log(city); // 'New York'

// 默认值
const { title = 'Untitled' } = {};
console.log(title); // 'Untitled'
    `,
    analysis: `
      <p>这个例子展示了 ES6 解构赋值的几种常见用法：</p>
      <ul>
        <li>数组解构：使用方括号 [] 进行解构，可以使用剩余参数语法 ...rest</li>
        <li>对象解构：使用花括号 {} 进行解构，可以使用嵌套解构</li>
        <li>默认值：当解构的值是 undefined 时，可以使用默认值</li>
      </ul>
      <p>解构赋值可以大大简化代码，使代码更加简洁和易读。</p>
    `
  }
} 